[PATCH] *-login: Add LOGIN_PROXY_FAILURE_TYPE_AUTH_NOT_REPLIED

Gbp-Pq: Name 0001-login-Add-LOGIN_PROXY_FAILURE_TYPE_AUTH_NOT_REPLIED.patch

managesieve-login-Support-LOGIN_PROXY_FAILURE_TYPE_A

===================================================================

Gbp-Pq: Name 0001-managesieve-login-Support-LOGIN_PROXY_FAILURE_TYPE_A.patch

[PATCH 5/5] submission-login: submission-proxy - Recognize 421 4.7.0 as connection-limit reply

When the backend signals that the user's connection limit has been
reached, do not classify the response as a generic temporary
authentication failure (which causes the proxy to reconnect). Map it
instead to LOGIN_PROXY_FAILURE_TYPE_AUTH_LIMIT_REACHED_REPLIED, which
suppresses retries and reports the failure as proxy_dest_connection_limit
in the login_aborted event/log line. This mirrors what imap-login does
for the [LIMIT] response code and pop3-login for [IN-USE].

Other 421 replies (typically server shutdown / fatal error) are mapped
to LOGIN_PROXY_FAILURE_TYPE_AUTH_REPLIED rather than AUTH_TEMPFAIL: 421
means "closing transmission channel" (RFC 5321 Section 4.2.1), so a
reconnect on the same destination is unlikely to help and should not
happen automatically.

Gbp-Pq: Name 0005-submission-login-submission-proxy-Recognize-421-4.7..patch

[PATCH] login-common, *-login: Add proxy_dest_connection_limit error_code to proxy_session_finished

If IMAP backend returns with [LIMIT] or POP3 backend returns with [IN-USE],
use this error code rather than the generic proxy_dest_auth_failed.
Error messages are also updated.

Gbp-Pq: Name 0001-login-common-login-Add-proxy_dest_connection_limit-e.patch

managesieve-login-Adjust-to-core-s-login_proxy_failu

===================================================================

Gbp-Pq: Name 0001-managesieve-login-Adjust-to-core-s-login_proxy_failu.patch

[PATCH] *-commin: Rename LOGIN_PROXY_FAILURE_TYPE_AUTH to LOGIN_PROXY_FAILURE_TYPE_AUTH_REPLIED

Gbp-Pq: Name 0001-commin-Rename-LOGIN_PROXY_FAILURE_TYPE_AUTH-to-LOGIN.patch

[PATCH 4/5] submission-login: client-authenticate - Reply 421 4.7.0 on mail_max_userip_connections

Until now the connection limit was reported via the same 454 4.7.0 reply
that is used for generic temporary authentication failures. That makes
proxies (including Dovecot's own submission proxy) treat the rejection as
a transient auth error and retry, which is futile when the limit is hit
and only obscures the actual cause in the proxy log.

Reply with 421 4.7.0 instead. RFC 5321 Section 4.2.1 specifies 421 as
"service shutting down, closing transmission channel", which is the
right signal for "do not retry on this connection". The 421 + 4.7.0
combination is unique among the 421 replies emitted by submission and is
used by the submission proxy to recognize this specifically as a
connection-limit reply rather than a generic 421 internal/shutdown.

Gbp-Pq: Name 0004-submission-login-client-authenticate-Reply-421-4.7.0.patch

[PATCH 3/5] lib-smtp: smtp-server - Expose smtp_server_connection_reply_immediate

The function already existed internally as a way to write a reply directly
to the output stream, bypassing the per-command reply queue. Make it part
of the public API so callers that need a reply on the wire before tearing
the connection down (where queued replies would otherwise be aborted) can
use it.

Gbp-Pq: Name 0003-lib-smtp-smtp-server-Expose-smtp_server_connection_r.patch

[PATCH 2/5] submission-login: client - Fix panic occurring at mail_max_userip_connections limit transgression

Panic was:
Panic: epoll_ctl(del, 8) failed: Bad file descriptor

Fixed by making sure the underlying smtp-server connection is always closed before the connection FD is closed.

Gbp-Pq: Name 0002-submission-login-client-Fix-panic-occurring-at-mail_.patch

[PATCH 1/5] login-common: client-common - Add client_disconnect() vfunc

Gbp-Pq: Name 0001-login-common-client-common-Add-client_disconnect-vfu.patch

[PATCH 3/3] lib-sieve: edit_mail_headers_parse() - Fix info leak via NUL-truncated header copy

i_strndup() stops at the first NUL byte, so embedded NULs caused field->data
to be shorter than field->size. This left stale heap data readable past the
copied content when callers treat data+body_offset as a string.

Adds a test-edit-mail unit test and a sieve testsuite case that both
exercise edit_mail_headers_parse() with a NUL byte embedded in a header
value. The unit test memcmp-verifies that the bytes after the NUL are
preserved; the sieve test triggers an invalid heap read detectable by
valgrind under the old code.

Gbp-Pq: Name 0003-lib-sieve-edit_mail_headers_parse-Fix-info-leak-via-.patch

[PATCH 2/3] lib-sieve: util: test-edit-mail - Adjust to changes in dovecot core lib-test

Gbp-Pq: Name 0002-lib-sieve-util-test-edit-mail-Adjust-to-changes-in-d.patch

[PATCH 1/3] lib-sieve: util: edit-mail - Fix writing to freed memory

Gbp-Pq: Name 0001-lib-sieve-util-edit-mail-Fix-writing-to-freed-memory.patch

[PATCH 12/12] config: doveconf -dF - Add dovecot_storage_version

Gbp-Pq: Name 0012-config-doveconf-dF-Add-dovecot_storage_version.patch

[PATCH 11/12] lib, lib-master: Move version_*() to lib/version.[ch]

Gbp-Pq: Name 0011-lib-lib-master-Move-version_-to-lib-version.-ch.patch

[PATCH 10/12] lib-master: Move config_version_find() from src/config/config-parser.c

Rename to dovecot_config_version_find() and expose it via
master-service-settings.h so non-config callers (e.g. the upcoming
dovecot_storage_version validation in master_service_settings_check())
can share the same supported-versions list. No behaviour change.

Gbp-Pq: Name 0010-lib-master-Move-config_version_find-from-src-config-.patch

[PATCH 09/12] config: Assume dovecot_config_version=0.0.0 is the same as the latest version

It's used for git builds.

Gbp-Pq: Name 0009-config-Assume-dovecot_config_version-0.0.0-is-the-sa.patch

[PATCH 08/12] doveadm: Fix ubsan unsigned integer overflow error

Gbp-Pq: Name 0008-doveadm-Fix-ubsan-unsigned-integer-overflow-error.patch

[PATCH 07/12] lib-index: Add keyed xxh64 strmap format v2, gated by config version

The on-disk hash stored in the strmap file is now optionally a keyed
xxh64_to_32() with a per-file random 64-bit IV stored in the file
header.  This replaces the previous plain crc32_str_nonzero() output
and hardens the strmap against deliberately-collided message-id
hashes.  The v1 (crc32) format remains fully readable and writable
so older configurations keep working without forced rebuilds.

On-disk:
 - v1 header is 8 bytes: version, 3 unused, uid_validity (unchanged).
 - v2 header is 16 bytes: version, compat_flags, 2 unused, uid_validity,
   hash_iv.  The first 8 bytes of v2 align with v1 byte-for-byte, so
   the open path reads 8 bytes, dispatches on version, and reads the
   trailing 8 bytes only for v2.

Runtime:
 - strmap->enable_xxh64 selects the format used when creating a new
   file (or recreating one whose uid_validity has changed).
 - view->format_version follows the on-disk file when one exists; for
   fresh files it follows the strmap-wide preference.
 - Renumber recreate_write() preserves view->format_version, so we
   never silently migrate an existing file across the threshold while
   it is still in use - the migration only happens at open time.
 - When enable_xxh64 is TRUE and the on-disk file is v1, open treats
   it as a version mismatch: the file is unlinked and the next sync's
   recreate_write() produces a v2 file.  Below the threshold v1 stays
   v1 indefinitely.
 - strmap_hash_str() dispatches per-view, so v1 files keep using
   crc32 hashes and v2 files use keyed xxh64 even in mixed setups.

Gbp-Pq: Name 0007-lib-index-Add-keyed-xxh64-strmap-format-v2-gated-by-.patch

[PATCH 06/12] lib-index: Rename crc32 variables/parameters to hash in strmap

Pure rename - no functional change. The stored 32-bit value is still
produced by crc32_str_nonzero(); only the identifiers change to prepare
for swapping the hash algorithm in the next commit.

recs_crc32 -> recs_hash, hash_key.crc32 -> hash_key.hash,
crc32_r -> hash_r, local crc32 -> hash, *crc32 -> *hashes.

Gbp-Pq: Name 0006-lib-index-Rename-crc32-variables-parameters-to-hash-.patch

[PATCH 05/12] lib-index: mail-index-strmap - Fix OOB read from truncated record size

Gbp-Pq: Name 0005-lib-index-mail-index-strmap-Fix-OOB-read-from-trunca.patch

[PATCH 04/12] lib: Key str_hash/strcase_hash with a random seed to prevent HashDoS

hash_init() fills a process-wide uint64_t hash_iv via random_fill()
at lib_init() time (after random_init()). str_hash() and strcase_hash()
pass hash_iv as the xxh64 seed so an attacker cannot predict bucket
placement and manufacture collision chains.

Gbp-Pq: Name 0004-lib-Key-str_hash-strcase_hash-with-a-random-seed-to-.patch

[PATCH 03/12] lib: Add str_stable_hash()

For now this is the same as str_hash(), but this is changed in a following
commit.

Gbp-Pq: Name 0003-lib-Add-str_stable_hash.patch

[PATCH 02/12] lib: Replace str_hash/strcase_hash with xxh64

Replaces the old ASU-derived shift-and-XOR hash with xxh64_to_32(),
which provides better distribution and avalanche properties.
strcase_hash feeds each i_toupper()'d byte through the streaming API.

Gbp-Pq: Name 0002-lib-Replace-str_hash-strcase_hash-with-xxh64.patch

[PATCH] lib: xxh64: fix byte ordering bug on big-endian systems

Convert from little-endian to host byte order where necessary.

Background at https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1146449

Gbp-Pq: Name 0001-lib-xxh64-fix-byte-ordering-bug-on-big-endian-system.patch

[PATCH 01/12] lib: Add XXH64 hash implementation

Adds a streaming XXH64 (non-cryptographic) hash with init/loop/result
API, a one-shot xxh64_data(), and an xxh64_to_32() XOR-fold inline.
Registered in hash_methods[] for use via the generic hash_method API.

Gbp-Pq: Name 0001-lib-Add-XXH64-hash-implementation.patch

[PATCH 2/2] imap-hibernate: Use imap-parser API for parsing DONE command

Replace the ad-hoc DONE/IDLE tokenizer with imap-parser.h: use
imap_parser_read_tag() to read the tag and imap_parser_read_word() to
read the DONE and IDLE keywords. This delegates bounds checks and
character validation to the shared parser.

Gbp-Pq: Name 0002-imap-hibernate-Use-imap-parser-API-for-parsing-DONE-.patch

[PATCH 1/2] imap-hibernate: Fix out-of-bounds read when parsing DONE command tag

The tag-skipping loop was missing a size>0 guard, so a malformed
DONE command with no space/CR/tab terminator after the tag would
read one byte past the end of the buffer. Also add a \0 check to
stop on embedded null bytes, which are not valid tag characters.

Gbp-Pq: Name 0001-imap-hibernate-Fix-out-of-bounds-read-when-parsing-D.patch

[PATCH 2/2] managesieve-login: client_skip_line() - Discard data when newline is not found

Without this, data without a newline (e.g., from a lone CR protocol violation
detected by the parser) stays in the buffer indefinitely. This prevents the
server from ever detecting client disconnect, causing a deadlock where both
sides wait for the other.

The post-login server-side client_skip_line() in managesieve-client.c already
handles this correctly by always calling i_stream_skip().

Gbp-Pq: Name 0002-managesieve-login-client_skip_line-Discard-data-when.patch

[PATCH 1/2] lib-managesieve: managesieve-parser - Fix handling of lone CR character

Gbp-Pq: Name 0001-lib-managesieve-managesieve-parser-Fix-handling-of-l.patch

[PATCH] lib-sieve: sieve-binary-code - Fix single byte oob stack buffer write in sieve_binary_emit_integer()

Gbp-Pq: Name 0001-lib-sieve-sieve-binary-code-Fix-single-byte-oob-stac.patch

[PATCH 3/3] lib-storage: thread - Limit ancestor chain traversal depth to prevent O(N^2) CPU usage

The per-message References limit (MAIL_THREAD_REFERENCES_MAX) prevents a
single crafted message from causing O(N^2) traversals in
thread_node_has_ancestor(). However, multiple crafted messages each
containing 1000 References entries can build an arbitrarily deep ancestor
chain across the mailbox, causing the same quadratic blowup spread over
many messages: processing email k costs O(k * MAIL_THREAD_REFERENCES_MAX)
steps, giving O(M^2 * MAIL_THREAD_REFERENCES_MAX) total for M emails.

Fix this by limiting the traversal depth in thread_node_has_ancestor() to
MAIL_THREAD_REFERENCES_MAX steps. When the limit is reached the link is
dropped, bounding per-email work to O(MAIL_THREAD_REFERENCES_MAX^2)
regardless of how deep the chain was built by prior messages.

Gbp-Pq: Name 0003-lib-storage-thread-Limit-ancestor-chain-traversal-de.patch

[PATCH 2/3] lib-storage: thread - Limit References: header msgid count to prevent O(N^2) CPU usage

Cap per-message References ingestion at MAIL_THREAD_REFERENCES_MAX (1000)
in mail_thread_map_add_mail(). Without this limit a single crafted email
with N unique Message-IDs triggers N(N-1)/2 ancestor traversals in
thread_node_has_ancestor(), allowing unauthenticated DoS via mail delivery.

Gbp-Pq: Name 0002-lib-storage-thread-Limit-References-header-msgid-cou.patch

[PATCH 1/3] lib-storage: thread - Avoid excessive data stack growth with many References msgids

Gbp-Pq: Name 0001-lib-storage-thread-Avoid-excessive-data-stack-growth.patch

[PATCH 14/14] lib-mail: Limit total MIME parameter count per message to 200 000

Content-Type and Content-Disposition parameters are both parsed through
parse_mime_parameters().  A message with many MIME parts each having many
parameters can accumulate millions of struct message_part_param entries.

Add remaining_mime_params to struct message_part_data_limits (combined
budget for both Content-Type and Content-Disposition), initialised to
MESSAGE_PART_DATA_MAX_TOTAL_MIME_PARAMS (200 000).  Cap params_count to the
remaining budget before allocating and deduct accordingly.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0014-lib-mail-Limit-total-MIME-parameter-count-per-messag.patch

[PATCH 13/14] lib-mail: Limit total Content-Language tag count per message to 100 000

A multipart message with many MIME parts each containing many language tags
can exhaust memory: the per-part RFC 2231 parser had no cumulative limit.

Add remaining_language_tags to struct message_part_data_limits, initialised
to MESSAGE_PART_DATA_MAX_TOTAL_LANGUAGE_TAGS (100 000).  Break out of the
tag-parsing loop in parse_content_language() once the budget reaches zero.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0013-lib-mail-Limit-total-Content-Language-tag-count-per-.patch

[PATCH 12/14] lib-mail: Limit total address count per message to 100 000

A message with millions of addresses across all its envelope headers can
exhaust memory when parsed (each struct message_address is ~100 bytes
regardless of whether the raw address is only a few bytes long).

Add remaining_addresses to struct message_part_data_limits, initialised to
MESSAGE_PART_DATA_MAX_TOTAL_ADDRESSES (100 000).  Pass the remaining budget
as max_addresses to message_address_parse_full() so parsing stops at the
limit, then deduct the actual count parsed from the budget.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0012-lib-mail-Limit-total-address-count-per-message-to-10.patch

[PATCH 11/14] lib-mail: Introduce struct message_part_data_limits and thread it through parsers

Add an empty struct message_part_data_limits and pass it by pointer through
message_part_data_parse_from_header() and message_part_envelope_parse_from_header().

No behaviour change: the struct has no fields yet and no limits are applied.
Subsequent commits add the individual limit fields and enforcement.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0011-lib-mail-Introduce-struct-message_part_data_limits-a.patch

[PATCH 10/14] lib-mail: Clamp hdr->value cumulatively against header_block_max_size

Until now header_block_max_size only bounded hdr->full_value via
value_buf.  Continued chunks returned to the caller via hdr->value were
left at the raw chunk size, so a caller that consumed hdr->value per
chunk without ever requesting use_full_value (e.g. the header-cache
path in index_mail_parse_header()) could accumulate the full raw header
size.  A pathological To: with millions of addresses could grow
mail->header_data and the cache write buffer to tens of megabytes each,
driving the imap process over vsz_limit on FETCH ENVELOPE.

Reinterpret header_block_total_size as the running sum of line_value_size
across all chunks of all headers, and clamp each new chunk against the
remaining header_block_max_size budget. Propagate the clamped size to
line->value_len in the two continued-line branches that previously left
it untouched. value_buf is bounded implicitly since every append uses
line_value_size. The up-front per-chunk clamp
(line->value_len = MIN(value_len, max_size)) is now subsumed by the
cumulative clamp and has been removed.

Update the truncation tests that were documenting the old
"value_len stays at raw chunk size" behavior.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Gbp-Pq: Name 0010-lib-mail-Clamp-hdr-value-cumulatively-against-header.patch

[PATCH 09/14] lib-storage: Cap per-header size in index_mail_get_header_stream()

Apply MESSAGE_HEADER_BLOCK_DEFAULT_MAX_SIZE (10 MB) to the header-filter
istream used for populating the header cache. A pathological single
header (for example a To: with millions of addresses) otherwise grows
mail->header_data and the cache write buffer in lockstep with the raw
header size, which can push the imap process over vsz_limit on FETCH
ENVELOPE / BODYSTRUCTURE.

On its own this change does not yet bound hdr->value delivery; that
requires the upcoming change to message_parse_header_next() to clamp
per-chunk value_len cumulatively. Setting the limit here now lets that
follow-up take effect without further touching this file.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Gbp-Pq: Name 0009-lib-storage-Cap-per-header-size-in-index_mail_get_he.patch

[PATCH 08/14] lib-mail: Make istream-header-filter's per-header size limit configurable

Until now the internal message_header_parser_ctx used the default
MESSAGE_HEADER_BLOCK_DEFAULT_MAX_SIZE (10 MB) cap. In practice that cap
only bounded hdr->full_value; per-chunk hdr->value was delivered in full
regardless. A subsequent change to message_parse_header_next() will
clamp hdr->value cumulatively as well, and at that point the 10 MB
default would silently truncate data for callers like mbox-save that
stream raw header bytes to storage.

Default the filter to SIZE_MAX (unlimited) to preserve the effective
behavior and add i_stream_header_filter_set_max_header_block_size() so
callers that genuinely want a cap (index_mail_get_header_stream()) can
opt in.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Gbp-Pq: Name 0008-lib-mail-Make-istream-header-filter-s-per-header-siz.patch

[PATCH 07/14] lib-mail: istream-header-filter - Use container_of() for struct casts

Replace the C-style downcasts from struct istream_private/iostream_private
to struct header_filter_istream with container_of(), matching the
convention used by other istream implementations in tree.

Gbp-Pq: Name 0007-lib-mail-istream-header-filter-Use-container_of-for-.patch

[PATCH 06/14] lib-storage/mbox: Explicitly disable the header block size limit

mbox_sync_parse_next_mail() appends each header's raw bytes into
ctx->header and writes them back when rewriting the mbox file. The
default MESSAGE_HEADER_BLOCK_DEFAULT_MAX_SIZE limit (10 MB) must not
apply here: any truncation would corrupt the mbox on rewrite.
Similarly, mbox_sync_parse_match_mail() feeds full raw header bytes
into the MD5 verifier.

Today the per-chunk hdr->value delivered by message_parse_header_next()
is not clamped cumulatively, so the limit only bites on full_value and
unknown headers pass through intact. That is about to change - a
subsequent commit will clamp hdr->value cumulatively. Explicitly
setting SIZE_MAX here locks in the intent and prevents a regression.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Gbp-Pq: Name 0006-lib-storage-mbox-Explicitly-disable-the-header-block.patch

[PATCH 05/14] lib-mail: Add count field to struct message_address_list

Add a count field and increment it in add_address() so callers can read
the number of parsed addresses directly from the list struct without
walking the linked list.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0005-lib-mail-Add-count-field-to-struct-message_address_l.patch

[PATCH 04/14] lib-mail: message-parser-from-parts: Enforce 50 MB all-headers-max-size limit

The preparsed (from-parts) header parser was not tracking
all_headers_total_size and never called message_parse_header_lower_limit(),
so the cumulative 50 MB header size limit was never applied when re-parsing
a message using cached part structure.

Fix by mirroring the same tracking that message-parser.c does in its
parse_next_header_block(): update all_headers_total_size for each parsed
header line, and call message_parse_header_lower_limit() with the remaining
budget when initialising the per-part header parser.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0004-lib-mail-message-parser-from-parts-Enforce-50-MB-all.patch

[PATCH 03/14] imap: Stream ENVELOPE to client without ostream memory duplication

Same fix as for BODYSTRUCTURE: avoid copying the envelope string into
the ostream ring buffer by using o_stream_set_max_buffer_size(0) +
o_stream_send_istream() with a continuation handler.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0003-imap-Stream-ENVELOPE-to-client-without-ostream-memor.patch

[PATCH 02/14] imap: Stream BODYSTRUCTURE to client without ostream memory duplication

For huge BODYSTRUCTURE responses (messages with many MIME parts),
o_stream_send_str() caused the ostream to copy the entire string into
its ring buffer when the stream was corked, doubling memory usage.

Use the same o_stream_set_max_buffer_size(0) + o_stream_send_istream()
pattern as fetch_stream_continue() so the ostream buffer stays at 0
bytes and the I/O loop handles flow control via WAIT_OUTPUT.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Gbp-Pq: Name 0002-imap-Stream-BODYSTRUCTURE-to-client-without-ostream-.patch

[PATCH 01/14] lib-mail: Reset charset translation buffer between MIME parts

If MIME part ended with an incomplete charset translation, the buffer was
kept for the next MIME part. This could have produced garbage in the next
MIME part, or a crash.

Fixes:
Panic: file message-decoder.c: line 232 (translation_buf_decode): assertion failed: (orig_size < CHARSET_MAX_PENDING_BUF_SIZE)

Gbp-Pq: Name 0001-lib-mail-Reset-charset-translation-buffer-between-MI.patch

[PATCH] lib-imap: imap-match - Fix excessive CPU usage caused by backtracking

Backport the NFA/non-backtracking algorithm from 2684624… while retaining the
byte-oriented matcher semantics of 2.4.1.

Original commit message:

Replace the recursive backtracking matcher with a Thompson-style NFA
simulation over grapheme clusters.

Each grapheme cluster of the compressed pattern becomes one state:
LITERAL, PERCENT (consume any number of non-separator clusters) or STAR
(consume any number of clusters including separators).  A virtual
ACCEPT position sits at index n_states.  Simulation tracks the set of
active positions in a bitmap.  Epsilon-closure (skipping a PERCENT or
STAR without consuming) is a single forward pass because the NFA is
linear: each state can only epsilon-skip to i+1.

The resulting match is O(n_data * n_pattern) regardless of pattern
shape, with no recursion and no backtracking, so there is no way for
a malicious pattern or mailbox name to trigger exponential CPU,
excessive stack depth, or unbounded memory.

IMAP_MATCH_YES / NO / CHILDREN / PARENT semantics are preserved:

- YES:      ACCEPT reachable after consuming all data.
- PARENT:   ACCEPT was active at some point while the next data
         grapheme cluster was the separator.
- CHILDREN: some active non-ACCEPT state remains after consuming all
         data, and either the data ends with a separator or an
         active state can still consume a separator (precomputed
         as sep_accept[]).

Inboxcase handling (case-insensitive comparison for the INBOX prefix
of data) and grapheme-cluster comparison are unchanged - the existing
match_gc logic is reused inline as literal_matches().
pattern_compress() and pattern_is_inboxcase() are unchanged.

Gbp-Pq: Name 0001-lib-imap-imap-match-Fix-excessive-CPU-usage-caused-b.patch

[PATCH 4/4] lib-mail: o_stream_dot_sendv() - Do not send unguarded '.' after bare '\r'

Gbp-Pq: Name 0004-lib-mail-o_stream_dot_sendv-Do-not-send-unguarded-.-.patch

[PATCH] lib-test: Require both lengths in test_assert_memcmp()

Gbp-Pq: Name 0001-lib-test-Require-both-lengths-in-test_assert_memcmp.patch

[PATCH] lib-test: Add test_assert_memcmp*()

Gbp-Pq: Name 0001-lib-test-Add-test_assert_memcmp.patch

[PATCH 3/4] lib-mail: o_stream_dot_sendv() - Use enumeration to define the items to inject

Gbp-Pq: Name 0003-lib-mail-o_stream_dot_sendv-Use-enumeration-to-defin.patch

[PATCH 2/4] lib-mail: o_stream_dot_sendv() - Fix boundary off by one

Gbp-Pq: Name 0002-lib-mail-o_stream_dot_sendv-Fix-boundary-off-by-one.patch

[PATCH 1/4] lib-mail: o_stream_dot_sendv() - Use I_MIN()

Gbp-Pq: Name 0001-lib-mail-o_stream_dot_sendv-Use-I_MIN.patch

[PATCH] lib-mail: ostream-dot - Optimize stream writing

Use i_memcspn() to figure out how much we can skip.

Gbp-Pq: Name 0001-lib-mail-ostream-dot-Optimize-stream-writing.patch

[PATCH 3/4] auth: db-oauth2: Add oauth2_audience setting, deprecate aud-as-scope fallback

Add a dedicated oauth2_audience setting checked against the token's aud
claim (RFC 7519 section 4.1.3) using the same tab-split AND-semantics as
oauth2_scope. Emit a deprecation warning when the existing aud fallback
in db_oauth2_token_in_scope() is triggered so operators know to migrate.

Gbp-Pq: Name 0003-auth-db-oauth2-Add-oauth2_audience-setting-deprecate.patch

[PATCH 2/4] auth: db-oauth2: Fix scope check to require all configured scopes

Switch token-in-scope check to AND semantics: all configured scopes
must be present in the token. Behaviour now matches the JWT path.

Gbp-Pq: Name 0002-auth-db-oauth2-Fix-scope-check-to-require-all-config.patch

[PATCH 1/4] auth: db-oauth2: Reduce nesting in token_in_scope via early return

Gbp-Pq: Name 0001-auth-db-oauth2-Reduce-nesting-in-token_in_scope-via-.patch

[PATCH] lib-sql: Run sql statement queries in their own data stack frame

Gbp-Pq: Name 0007-lib-sql-Run-sql-statement-queries-in-their-own-data-.patch

[PATCH 6/6] auth: passdb_sql: connect before expanding query variables

sql_lookup_pass() calls settings_get_params() with an SQL escape func that
requires a live connection. If the DB is disconnected, the error propagated
as "Failed to parse configuration" instead of a DB connectivity error.

Call sql_connect() first; fail with "Not connected to database" directly
if it returns -1.

Gbp-Pq: Name 0006-auth-passdb_sql-connect-before-expanding-query-varia.patch

[PATCH 5/6] lib-sql: Make escape_string return int with error_r, fail instead of unsafe fallback

Change escape_string driver vfunc and sql_escape_string() to return int
with separate error_r output parameter. On failure (e.g. not connected),
return -1 instead of falling back to unsafe escaping.

Move escaping from sql_statement_bind_str() to sql_statement_get_query()
so errors can be propagated to callers. Add failed_error field to
sql_transaction_context for deferred error reporting at commit time.

Gbp-Pq: Name 0005-lib-sql-Make-escape_string-return-int-with-error_r-f.patch

[PATCH] lib-sql: Use strchr() based while loop to fill template

This is much faster than going one byte at a time.

Gbp-Pq: Name 0001-lib-sql-Use-strchr-based-while-loop-to-fill-template.patch

[PATCH] lib-sql: driver-sqlite - Use sqlite3_snprintf() to quote values

This does it the sqlite3 way.

Gbp-Pq: Name 0001-lib-sql-driver-sqlite-Use-sqlite3_snprintf-to-quote-.patch

[PATCH 4/6] lib-var-expand: Change escape func signature to return int with error_r

Wire error propagation in var_expand_program_execute_one_real() so a
failing escape function causes the expansion to return -1.

Update all implementations (passdb-sql, userdb-sql, db-ldap, dict-ldap,
auth-request-var-expand) and replace the unsafe auth_request_escape_func_t
cast in auth-request-var-expand.c with a proper bridge wrapper.

Gbp-Pq: Name 0004-lib-var-expand-Change-escape-func-signature-to-retur.patch

[PATCH 3/6] lib-sql: Add sql_commit_schedule_delayed() helper

Gbp-Pq: Name 0003-lib-sql-Add-sql_commit_schedule_delayed-helper.patch

[PATCH 2/6] lib-sql: Extract sql_query_callback_delayed() helper

Gbp-Pq: Name 0002-lib-sql-Extract-sql_query_callback_delayed-helper.patch

[PATCH] lib-sql: Add sql_result_new_error() helper

Gbp-Pq: Name 0001-lib-sql-Add-sql_result_new_error-helper.patch

[PATCH] lib-sql: sql-api - Implement async calls for drivers that can't

Changes the behaviour of asynchronous functions to be truly asynchronous
even if the underlying driver isn't capable of doing this. Implemented
by adding immediate timeouts to call the callbacks after returning from the
synchronous function and ending up back to ioloop.

Gbp-Pq: Name 0001-lib-sql-sql-api-Implement-async-calls-for-drivers-th.patch

[PATCH 2/4] lib-compression: Iterate instead of recursing on zero-output decompress chunks

istream-lz4, istream-zlib and istream-bzlib each retried a read that
produced no output by tail-calling their own read function. A crafted
compressed stream can contain an unbounded number of chunks/steps that
each decompress to zero bytes - e.g. an lz4 stream of single-byte chunks
that each decode to nothing - so an attacker controlling the compressed
data can drive recursion depth proportional to the chunk count. Tail-call
optimization is not guaranteed, so this can exhaust the stack and crash
the process reading the stream.

Replace the recursive calls with continue inside the for(;;) loop
introduced in the previous commit, keeping stack usage O(1). Add a
regression test that feeds istream-lz4 a stream of 100000 empty chunks
and reads it in a single call.

Gbp-Pq: Name 0002-lib-compression-Iterate-instead-of-recursing-on-zero.patch

[PATCH 1/4] lib-compression: wrap *_read() in for(;;) loop (reindent only)

Prepare for the next commit: wrap the body of i_stream_lz4_read(),
i_stream_bzlib_read(), and i_stream_zlib_read() in a for(;;) loop.
No logic change; all paths still return on the first iteration.
Separating the indent churn makes the actual fix easier to review.

Gbp-Pq: Name 0001-lib-compression-wrap-_read-in-for-loop-reindent-only.patch

global-Fix-spelling

===================================================================

Gbp-Pq: Name 0001-global-Fix-spelling.patch

[PATCH] lib-compression: istream-zlib - Use container_of() macro

Gbp-Pq: Name 0001-lib-compression-istream-zlib-Use-container_of-macro.patch

[PATCH] lib-compression: Don't calculate crc32 if using zlib in deflate mode

Gbp-Pq: Name 0001-lib-compression-Don-t-calculate-crc32-if-using-zlib-.patch

[PATCH] lib-compression: istream-lz4 - Try again if no data was decompressed

Gbp-Pq: Name 0001-lib-compression-istream-lz4-Try-again-if-no-data-was.patch

[PATCH] lib-compression: istream-lz4 - Ensure uncompressed chunk size is not 0

Gbp-Pq: Name 0001-lib-compression-istream-lz4-Ensure-uncompressed-chun.patch

[PATCH 3/4] lib-compression: istream-zstd - Guard against no-progress loop in read

If ZSTD_decompressStream() returns with neither input consumed nor
output produced, the read loop would spin indefinitely. Add a check
after each call: if input.pos is unchanged and output.pos is zero,
treat it as a corrupt stream (EIO).

Gbp-Pq: Name 0003-lib-compression-istream-zstd-Guard-against-no-progre.patch

[PATCH 4/4] lib-compression: test - Add zero-len frame test for all handlers

Verify that successive empty compressed frames produce a clean EOF
across all compression algorithms. lz4 is limited to one frame as it
uses a custom single-stream format without concatenation support.

Gbp-Pq: Name 0004-lib-compression-test-Add-zero-len-frame-test-for-all.patch

[PATCH 2/2] lib-sieve: storage: file - Validate script stat path through dir_fd

Extend the symlink-escape protection added in the previous commit to the
stat performed by sieve_file_script_open(): an "include :personal" lookup
or any other indirect path that triggers sieve_file_script_stat() also
needs to refuse a symlink whose target leaves the personal storage
directory, otherwise the existence check succeeds and the file is opened
later via the safe path with an unhelpful "permission denied".

Add sieve_file_script_stat_safe(), which uses fstatat(AT_SYMLINK_NOFOLLOW)
to obtain the entry's own stat (lnk_st) and then, only if the entry is a
symlink, opens it through sieve_file_storage_open_safe() to validate the
target stays inside dir_fd and to fetch the resolved target's stat (st)
via fstat(). Non-symlink entries skip the open entirely.

Use the new helper in sieve_file_script_open() whenever fstorage->dir_fd
is available, falling back to the unsafe lstat+stat variant for
non-personal or single-file storages.

Gbp-Pq: Name 0002-lib-sieve-storage-file-Validate-script-stat-path-thr.patch

[PATCH 1/2] lib-sieve: storage: file - Refuse symlinks escaping personal storage directory

Pigeonhole's file storage followed any symlink encountered while resolving a
script path, including symlinks in personal (user-writable) storage whose
target lay outside the storage directory. In some non-recommended
configurations a user could exploit this through the include extension:
an "include :personal name;" lookup of ~/sieve/name.sieve transparently
followed a user-placed to e.g. another user's file readable by the mail
process, leaking its contents (or causing it to be parsed as Sieve).
Normally this shouldn't be possible, because sieve processes shouldn't
have any more privileges to read files than the local system user creating
the symlink.

Open the canonical (realpath'd) personal storage directory at storage init
time and keep an O_DIRECTORY|O_CLOEXEC fd to it. Resolve script content
reads through this fd by routing sieve_file_script_get_stream() via a new
sieve_file_storage_open_safe() wrapper around t_openat_safe(), which:

 - opens each path component with O_NOFOLLOW so symlinks are detected
   explicitly rather than transparently followed;
 - follows symlinks only when their (recursively resolved) target stays
   beneath dir_fd, refusing absolute targets and `..` past the storage
   root with ELOOP;
 - caps the symlink-hop count to bound resolution time.

Anchoring at dir_fd makes the lookup TOCTOU-safe even when intermediate
path components are mutated on disk concurrently: resolution stays
relative to the original directory inode and the safe walker still rejects
any target that leaves it.

Apply the protection only when storage->is_personal is set; admin-managed
global storage is trusted and may legitimately use cross-boundary symlinks.
Single-file storages (is_file=TRUE) keep dir_fd at -1 and fall back to the
existing open path. Also guard the dir_fd open with S_ISDIR() to handle the
autodetect quirk where storage_path can refer to a regular file even when
is_file is FALSE.

Gbp-Pq: Name 0001-lib-sieve-storage-file-Refuse-symlinks-escaping-pers.patch

[PATCH 5/5] lib: Add comments about memory allocations and string functions preserving errno

Gbp-Pq: Name 0005-lib-Add-comments-about-memory-allocations-and-string.patch

[PATCH 4/5] acl: dovecot-acl-list is never supposed to be a symlink - use O_NOFOLLOW flag

Gbp-Pq: Name 0004-acl-dovecot-acl-list-is-never-supposed-to-be-a-symli.patch

[PATCH 3/5] lib: Add t_openat_safe_dir()

Gbp-Pq: Name 0003-lib-Add-t_openat_safe_dir.patch

[PATCH 2/5] lib: path-util - Add t_openat_safe() for jailed openat() resolution

Add a helper that opens a path relative to a directory fd while refusing
any resolution that escapes that directory. Each component is opened with
O_NOFOLLOW so symlinks are detected explicitly rather than transparently
followed; symlinks are then resolved manually and only honoured when their
(recursively resolved) target also stays beneath the base fd. Absolute
symlink targets, leading '/', and '..' past the base are rejected with
errno=ELOOP. Symlink chains are bounded by
PATH_UTIL_OPENAT_SAFE_MAX_SYMLINKS hops.

Anchoring resolution at a caller-held base_fd makes the lookup TOCTOU-safe
even when intermediate path components are mutated on disk concurrently:
the kernel resolves all openat() lookups relative to the original
directory inode that base_fd refers to, so an attacker mutating path
components on the filesystem cannot redirect resolution.

This is the portable counterpart to Linux's openat2() with RESOLVE_BENEATH
and is intended for callers that need to safely look up files under a
user-writable directory (e.g. a Sieve script storage directory).

Gbp-Pq: Name 0002-lib-path-util-Add-t_openat_safe-for-jailed-openat-re.patch

[PATCH 1/5] lib: i_close_fd*() - Document that it preserves errno

Gbp-Pq: Name 0001-lib-i_close_fd-Document-that-it-preserves-errno.patch

[PATCH 2/2] lib-sieve: actions - Create fileinto mailbox without the autocreate flag

Stop setting MAILBOX_FLAG_AUTO_CREATE/SUBSCRIBE in act_store. Instead, on
mailbox_open() returning MAIL_ERROR_NOTFOUND, create the mailbox explicitly
with sieve_act_store_create_mailbox() when autocreation is enabled (the
:create side effect already creates it explicitly).

This makes the creation go through the normal ACL CREATE gate, so a fileinto
(with lda_mailbox_autocreate=yes) or fileinto :create can no longer create a
mailbox in a shared or public namespace that the user lacks the CREATE right
for.

A permission failure to create the mailbox is classified by
sieve_act_store_create_error_status(): for a user's personal script it is a
permanent failure (implicit keep), while for a global (administrator-defined)
script it is deferred (temporary failure), so the administrator notices the
script is behaving in a way they did not intend.

Gbp-Pq: Name 0002-lib-sieve-actions-Create-fileinto-mailbox-without-th.patch

[PATCH 1/2] lib-sieve: actions - Split mailbox creation into sieve_act_store_create_mailbox()

Pure refactoring with no functional change: move the mailbox_create() /
subscribe / reopen sequence out of the "mailbox" extension's :create side
effect (seff_mailbox_create_pre_execute) into a new reusable
sieve_act_store_create_mailbox() helper.

Gbp-Pq: Name 0001-lib-sieve-actions-Split-mailbox-creation-into-sieve_.patch

[PATCH 2/2] lib-storage: Remove MAILBOX_FLAG_AUTO_CREATE and MAILBOX_FLAG_AUTO_SUBSCRIBE

These flags were set only by mail delivery (lib-lda) and Sieve fileinto
(Pigeonhole), both of which now create the target mailbox explicitly with
mailbox_create(). Nothing sets the flags anymore, so remove them and drop
the flag checks from mailbox_is_autocreated() and mailbox_is_autosubscribed().

As a result mailbox_is_autocreated() reflects only mailboxes that virtually
already exist (the user's INBOX and admin-configured "auto" mailboxes), so
the ACL plugin again enforces the CREATE right for delivery-autocreated
mailboxes in shared and public namespaces.

Gbp-Pq: Name 0002-lib-storage-Remove-MAILBOX_FLAG_AUTO_CREATE-and-MAIL.patch

[PATCH 1/2] lib-lda: mail-deliver - Autocreate delivery mailbox via explicit mailbox_create()

Instead of relying on MAILBOX_FLAG_AUTO_CREATE to have mailbox_open()
implicitly create the target, open it and, on MAIL_ERROR_NOTFOUND,
create it explicitly when lda_mailbox_autocreate is enabled. This makes
the creation go through the normal mailbox_create() path (including ACL
checks) and removes one of the two users of the autocreate mailbox flags.

Gbp-Pq: Name 0001-lib-lda-mail-deliver-Autocreate-delivery-mailbox-via.patch

[PATCH] imap-login: Fix excessive memory growth with pre-login ID command

The pre-login ID parser reset the per-argument line and list limits after
every argument, so nothing bounded the number of key/value pairs. Each
external key grew log_reply and added a distinct event field (a linear
scan, making it O(N^2)), allowing a pre-auth CPU/memory amplification.

Account at most 30 pairs (per RFC 2971) into the logging and client_id
bookkeeping. Internal x-* parameter handlers still run for pairs beyond
the limit, since a trusted proxy may legitimately forward more fields.

Gbp-Pq: Name 0001-imap-login-Fix-excessive-memory-growth-with-pre-logi.patch

[PATCH] imap-login: Add comments to internal ID command parameter handling

Gbp-Pq: Name 0001-imap-login-Add-comments-to-internal-ID-command-param.patch

[PATCH] lib-sieve: Reduce CPU limit check interval in :contains and :matches matchers

Reduce the interval to 64 so worst-case work between checks is ~64 MiB.
cpu_limit_exceeded() is a signal-counter comparison with no syscall, so
the higher call frequency has no measurable cost.

Gbp-Pq: Name 0008-lib-sieve-Reduce-CPU-limit-check-interval-in-contain.patch

[PATCH 7/7] lib-sieve: Log an info line when opening a CPU-disabled script

sieve_binary_check_executable() blocks execution when a script's
persisted cumulative CPU usage already exceeds sieve_max_cpu_time, but
only logged the block at debug level. With cumulative tracking now
sticky across redeliveries via the per-user sieve-rusage file, the
script can stay blocked indefinitely until the resource_usage_timeout
decay or admin intervention; operators benefit from a per-attempt
record of that block at info level.

Promote the existing debug log to e_info and include the cumulative
CPU usage. The caller continues to emit its own error message on the
failed open (lda-sieve, imap-sieve, imap-filter-sieve plugin paths).

Gbp-Pq: Name 0007-lib-sieve-Log-an-info-line-when-opening-a-CPU-disabl.patch

[PATCH 6/7] lib-sieve: Log a warning when cumulative CPU exceeds the limit

sieve_binary_record_resource_usage() returned FALSE when the script's
cumulative CPU time crossed sieve_max_cpu_time, but the only log line
on that path was a debug-level "Updated cumulative resource usage"
emitted on every recording, with no signal at the actual disable
transition. Operators had to infer the disable from later "Failed to
open script ... (cumulative resource limit exceeded)" errors on
subsequent deliveries.

Emit a warning at the transition point, including the cumulative CPU
usage that triggered it.

Gbp-Pq: Name 0006-lib-sieve-Log-a-warning-when-cumulative-CPU-exceeds-.patch

[PATCH 5/7] lib-sieve: file storage: Remove orphan compiled binaries on delete and rename

DELETESCRIPT and RENAMESCRIPT only operated on the .sieve file and
left the matching compiled binary (.svbin) on disk. The orphan was
never referenced again under that name, so it accumulated as wasted
disk space until something else (manual cleanup, account removal)
removed it.

Unlink fscript->bin_path alongside the .sieve operation. The unlink is
best-effort: failures other than ENOENT are logged but do not fail the
DELETE/RENAME.

Gbp-Pq: Name 0005-lib-sieve-file-storage-Remove-orphan-compiled-binari.patch

[PATCH 4/7] lib-sieve: Switch sieve_max_cpu_time enforcement to time-decayed re-enable

When a user's cumulative CPU time exceeded sieve_max_cpu_time, the
script was permanently disabled. SIEVE_BINARY_FLAG_RESOURCE_LIMIT was
set in the binary header on first overrun and was never cleared by
the resource_usage_timeout decay (which only zeroed the cpu_time
field), so sieve_binary_check_executable() refused execution forever
unless the binary was recompiled or an admin manually wiped the file.

Replace the sticky-flag model with one driven purely by the persisted
cumulative cpu_time, decayed by resource_usage_timeout:

 - Drop SIEVE_BINARY_FLAG_RESOURCE_LIMIT and the enum that defined it;
   nothing reads sbin->header.flags anymore.
 - sieve_binary_check_executable() and sieve_binary_check_resource_usage()
   call sieve_resource_usage_is_excessive() on the current cumulative
   cpu_time. Raising sieve_max_cpu_time now correctly re-enables a
   previously over-limit user without further intervention.
 - Gate per-user file persistence on the per-run delta, not the
   cumulative total. A refused-without-running attempt has a zero
   delta, skips the file write, and leaves update_time at the moment
   work was actually consumed. After resource_usage_timeout seconds
   of inactivity (or only-trivial deliveries) the next load decays
   the cpu_time to zero and the user is allowed to run again.

The on-disk per-user sieve-rusage file format becomes:

    V1 <cpu-secs> <update-time>

Gbp-Pq: Name 0004-lib-sieve-Switch-sieve_max_cpu_time-enforcement-to-t.patch

[PATCH 3/7] lib-sieve: Rename on-disk header rusage fields to unused_*

The .svbin header's resource_usage fields no longer carry data: they
are zeroed on save and discarded on load. Cumulative CPU tracking
lives in the per-user sieve-rusage file, and the in-memory carry-over
lives in sbin->persisted_rusage.

Flatten the nested resource_usage struct and rename the fields to
unused_update_time and unused_cpu_time_msecs so it is obvious the
fields are kept only for on-disk format compatibility. The memory
layout of struct sieve_binary_header is unchanged.

Gbp-Pq: Name 0003-lib-sieve-Rename-on-disk-header-rusage-fields-to-unu.patch

[PATCH 2/7] lib-sieve: Drop binary-header resource usage tracking

With the per-user sieve-rusage file now authoritative for personal
storages, the .svbin header no longer needs to carry CPU usage. Admin
storages (sieve_before/after, default location) cannot be re-uploaded
by the user, so cross-run tracking is unnecessary there; the runtime
sieve_max_cpu_time check still enforces the per-execution limit.

Move the in-memory cumulative carry-over from sbin->header.resource_usage
to a dedicated sbin->persisted_rusage substruct. The on-disk header
struct now solely represents the wire format and is zeroed on every
save; the in-memory carry-over no longer overloads it. Drop the now-dead
"resource usage" section from sieve_binary_dumper_run() (the on-disk
fields are always zero, so the section never produced output).

Gbp-Pq: Name 0002-lib-sieve-Drop-binary-header-resource-usage-tracking.patch

[PATCH 1/7] lib-sieve: Add per-user sieve-rusage file for cumulative CPU tracking

Cumulative resource usage was previously stored in each compiled Sieve
binary's (.svbin) header. Because the binary file is keyed by script
name, a user could reset their CPU budget by uploading the same script
under a different name (PUTSCRIPT newname + SETACTIVE newname),
RENAMESCRIPT, or DELETESCRIPT followed by PUTSCRIPT under another
name. Each such operation produced a fresh .svbin with zero counter,
allowing the sieve_max_cpu_time limit to be bypassed indefinitely.

Track cumulative CPU per user instead, in <INBOX-namespace-root>/sieve-rusage.
The file persists across all script renames, deletions, and re-uploads,
since it is not tied to any particular script name. Tracking is enabled
only for personal storages where the user's INBOX namespace has a
filesystem path; admin/default storages are unaffected here.

The on-disk format is a single ASCII line:

    V1 <flags> <cpu-secs> <update-time>

CPU time is rounded up to whole seconds when persisted; sub-second
precision is preserved only for the in-memory accumulation within a
single execution. The file is updated by writing a new copy via
file_dotlock_open_mode() and replacing the original via
file_dotlock_replace(). Concurrent writers are serialized through the
dotlock; readers do not need a lock because the rename is atomic.

The .svbin header still carries its original resource_usage struct as
the active fallback when no per-user file is available; a follow-up
commit drops that path.

Gbp-Pq: Name 0001-lib-sieve-Add-per-user-sieve-rusage-file-for-cumulat.patch

[PATCH] lib-sieve: sieve-storage - Fix panic caused by flawed detection of personal storage type

Recent commit d82c2e624e4a9c364a6fa58fad0938ae5578660c added the is_personal
flag, but it is assigned too late. Fix this issue by assigning this flag in the
earliest allocation function.

This issue commonly surfaces when people forget to set an appropriate type for a
script storage definition, in which case the "personal" type is the default.

Panic was:
Panic: file sieve-file-storage-active.c: line 33
(sieve_file_storage_active_read_link): assertion failed: (fstorage->active_path != NULL)

Gbp-Pq: Name 0001-lib-sieve-sieve-storage-Fix-panic-caused-by-flawed-d.patch